define('ace/mode/latex_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules

  var LatexHighlightRules = function() {
    this.$rules = {
      'start': [{
        token: 'comment',
        regex: '%.*$'
      }, {
        token: ['keyword', 'lparen', 'variable.parameter', 'rparen', 'lparen', 'storage.type', 'rparen'],
        regex: '(\\\\(?:documentclass|usepackage|input))(?:(\\[)([^\\]]*)(\\]))?({)([^}]*)(})'
      }, {
        token: ['keyword', 'lparen', 'variable.parameter', 'rparen'],
        regex: '(\\\\(?:label|v?ref|cite(?:[^{]*)))(?:({)([^}]*)(}))?'
      }, {
        token: ['storage.type', 'lparen', 'variable.parameter', 'rparen'],
        regex: '(\\\\begin)({)(verbatim)(})',
        next: 'verbatim'
      }, {
        token: ['storage.type', 'lparen', 'variable.parameter', 'rparen'],
        regex: '(\\\\begin)({)(lstlisting)(})',
        next: 'lstlisting'
      }, {
        token: ['storage.type', 'lparen', 'variable.parameter', 'rparen'],
        regex: '(\\\\(?:begin|end))({)([\\w*]*)(})'
      }, {
        token: 'storage.type',
        regex: /\\verb\b\*?/,
        next: [{
          token: ['keyword.operator', 'string', 'keyword.operator'],
          regex: '(.)(.*?)(\\1|$)|',
          next: 'start'
        }]
      }, {
        token: 'storage.type',
        regex: '\\\\[a-zA-Z]+'
      }, {
        token: 'lparen',
        regex: '[[({]'
      }, {
        token: 'rparen',
        regex: '[\\])}]'
      }, {
        token: 'constant.character.escape',
        regex: '\\\\[^a-zA-Z]?'
      }, {
        token: 'string',
        regex: '\\${1,2}',
        next: 'equation'
      }],
      'equation': [{
        token: 'comment',
        regex: '%.*$'
      }, {
        token: 'string',
        regex: '\\${1,2}',
        next: 'start'
      }, {
        token: 'constant.character.escape',
        regex: '\\\\(?:[^a-zA-Z]|[a-zA-Z]+)'
      }, {
        token: 'error',
        regex: '^\\s*$',
        next: 'start'
      }, {
        defaultToken: 'string'
      }],
      'verbatim': [{
        token: ['storage.type', 'lparen', 'variable.parameter', 'rparen'],
        regex: '(\\\\end)({)(verbatim)(})',
        next: 'start'
      }, {
        defaultToken: 'text'
      }],
      'lstlisting': [{
        token: ['storage.type', 'lparen', 'variable.parameter', 'rparen'],
        regex: '(\\\\end)({)(lstlisting)(})',
        next: 'start'
      }, {
        defaultToken: 'text'
      }]
    }

    this.normalizeRules()
  }
  oop.inherits(LatexHighlightRules, TextHighlightRules)

  exports.LatexHighlightRules = LatexHighlightRules
})

define('ace/mode/rdoc_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/lib/lang', 'ace/mode/text_highlight_rules', 'ace/mode/latex_highlight_rules'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var lang = require('../lib/lang')
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules
  var LaTeXHighlightRules = require('./latex_highlight_rules')

  var RDocHighlightRules = function() {
    this.$rules = {
      'start': [
        {
          token: 'comment',
          regex: '%.*$'
        }, {
          token: 'text', // non-command
          regex: '\\\\[$&%#\\{\\}]'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:name|alias|method|S3method|S4method|item|code|preformatted|kbd|pkg|var|env|option|command|author|email|url|source|cite|acronym|href|code|preformatted|link|eqn|deqn|keyword|usage|examples|dontrun|dontshow|figure|if|ifelse|Sexpr|RdOpts|inputencoding|usepackage)\\b',
          next: 'nospell'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:[a-zA-Z0-9]+|[^a-zA-Z0-9])'
        }, {
          token: 'paren.keyword.operator',
          regex: '[[({]'
        }, {
          token: 'paren.keyword.operator',
          regex: '[\\])}]'
        }, {
          token: 'text',
          regex: '\\s+'
        }
      ],
      'nospell': [
        {
          token: 'comment',
          regex: '%.*$',
          next: 'start'
        }, {
          token: 'nospell.text', // non-command
          regex: '\\\\[$&%#\\{\\}]'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:name|alias|method|S3method|S4method|item|code|preformatted|kbd|pkg|var|env|option|command|author|email|url|source|cite|acronym|href|code|preformatted|link|eqn|deqn|keyword|usage|examples|dontrun|dontshow|figure|if|ifelse|Sexpr|RdOpts|inputencoding|usepackage)\\b'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:[a-zA-Z0-9]+|[^a-zA-Z0-9])',
          next: 'start'
        }, {
          token: 'paren.keyword.operator',
          regex: '[[({]'
        }, {
          token: 'paren.keyword.operator',
          regex: '[\\])]'
        }, {
          token: 'paren.keyword.operator',
          regex: '}',
          next: 'start'
        }, {
          token: 'nospell.text',
          regex: '\\s+'
        }, {
          token: 'nospell.text',
          regex: '\\w+'
        }
      ]
    }
  }

  oop.inherits(RDocHighlightRules, TextHighlightRules)

  exports.RDocHighlightRules = RDocHighlightRules
})

define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module', 'ace/range'], function(require, exports, module) {
  'use strict'

  var Range = require('../range').Range

  var MatchingBraceOutdent = function() {};

  (function() {
    this.checkOutdent = function(line, input) {
      if (!/^\s+$/.test(line)) { return false }

      return /^\s*\}/.test(input)
    }

    this.autoOutdent = function(doc, row) {
      var line = doc.getLine(row)
      var match = line.match(/^(\s*\})/)

      if (!match) return 0

      var column = match[1].length
      var openBracePos = doc.findMatchingBracket({ row: row, column: column })

      if (!openBracePos || openBracePos.row == row) return 0

      var indent = this.$getIndent(doc.getLine(openBracePos.row))
      doc.replace(new Range(row, 0, row, column - 1), indent)
    }

    this.$getIndent = function(line) {
      return line.match(/^\s*/)[0]
    }
  }).call(MatchingBraceOutdent.prototype)

  exports.MatchingBraceOutdent = MatchingBraceOutdent
})

define('ace/mode/rdoc', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text', 'ace/mode/rdoc_highlight_rules', 'ace/mode/matching_brace_outdent'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var TextMode = require('./text').Mode
  var RDocHighlightRules = require('./rdoc_highlight_rules').RDocHighlightRules
  var MatchingBraceOutdent = require('./matching_brace_outdent').MatchingBraceOutdent

  var Mode = function(suppressHighlighting) {
    this.HighlightRules = RDocHighlightRules
    this.$outdent = new MatchingBraceOutdent()
    this.$behaviour = this.$defaultBehaviour
  }
  oop.inherits(Mode, TextMode);

  (function() {
    this.getNextLineIndent = function(state, line, tab) {
      return this.$getIndent(line)
    }
    this.$id = 'ace/mode/rdoc'
  }).call(Mode.prototype)

  exports.Mode = Mode
});
(function() {
  window.require(['ace/mode/rdoc'], function(m) {
    if (typeof module === 'object' && typeof exports === 'object' && module) {
      module.exports = m
    }
  })
})()
